{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## series对象\n",
    "series对象是一个带索引数据构成的一维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1\n",
       "1    2\n",
       "2    3\n",
       "3    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([1,2,3,4])\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过**values属性**和**index属性**获取数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4], dtype=int64)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=4, step=1)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series 和 numpy的本质区别是**索引**\n",
    "- numpy通过**隐式定义**的整数索引来获取数值\n",
    "- series是**显式定义**\n",
    "可以把series看作**特殊的字典**，可以用字典来创建series对象，与字典不同的是，series对象还支持**数组形式的操作**，比如**切片**\n",
    "\n",
    "**创建series对象**\n",
    "`pd.Series(data, index=index)`\n",
    "- data可以是**列表或numpy数组**index是可选对象\n",
    "- data也可以是**标量**，重复到索引上\n",
    "- data还可以是**字典**，index默认是字典键"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dataframe对象\n",
    "既可作为一个**通用性numpy数组**，也可以看作**特殊的字典**\n",
    "- dataframe有一个**index属性**可以获取**索引标签**\n",
    "- 还有一个**columns属性**，是存放**列标签的index**对象\n",
    "\n",
    "**创建dataframe对象**\n",
    "1. 通过单个series对象创建 `pd.DataFrame(population,columns=['populations'])#population是一个series对象`\n",
    "2. 通过字典列表创建\n",
    "3. 通过series对象字典创建\n",
    "4. 通过numpy二维数组创建\n",
    "5. 通过numpy结构化数组创建\n",
    "\n",
    "## Index对象\n",
    "可以将他看作一个**不可变数组**或**有序集合**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据取值与选择\n",
    "### series数据选择方法\n",
    "1. 将series看作字典\n",
    " - 提供了键值对的映射\n",
    " - 用字典的表达式和方法来检测键/索引和值\n",
    " - 用字典语法调整数据\n",
    "2. 将series看作一维数组\n",
    " - 具备和numpy数组一样的数据选择功能，**索引，掩码，花哨的索引**\n",
    "    **使用显示索引作切片时，结果包含最后一个索引，用隐式索引时则不包含**\n",
    "3. 索引器：`loc` `iloc` 和 `ix`\n",
    " - 他们不是series对象的函数方法，而是**暴露切片接口的属性**\n",
    " - **loc属性**，表示取值和切片都是**显性**的 (**标签索引**)\n",
    " - **iloc属性**，表示取值和切片都是**隐性**的 （**位置索引**）\n",
    " - **ix属性**，主要**用于dataframe**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dataframe数据选择方法\n",
    "1. 将DataFrame看作字典\n",
    " - 通过对列名进行字典形式的取值获取数据 `data['area']`\n",
    " - 用属性形式选择纯字符串列名的数据`data.area` (此方法并不通用**如果列名不是纯字符串**不能使用)\n",
    " - 还可以用字典形式的语法调整对象\n",
    "2. 将DataFrame看作二维数组\n",
    " - 用values 属性按行查看数组数据 `data.values`\n",
    " - 对DataFrame 进行行列转置`data.T`\n",
    " - 通过iloc 索引器，我们就可以像对待NumPy数组一样索引Pandas的底层数组`data.iloc[:3, :2]`  `data.loc[:'Illinois', :'pop']`\n",
    " - 使用ix 索引器可以实现一种混合效果`data.ix[:3, :'pop']`  `data.loc[data.density > 100, ['pop', 'density']]`\n",
    " - 任何一种取值方法都可以用于调整数据,和NumPy 的常用方法是相同的 `data.iloc[0, 2] = 90`\n",
    "3. 其他取值方法 \n",
    "```\n",
    "data['Florida':'Illinois']   data[1:3]   data[data.density > 100]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas数值运算方法\n",
    "Pandas 继承了NumPy 的功能,**通用函数**是关键。\n",
    "\n",
    "#### 通用函数：保留索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    6\n",
       "1    3\n",
       "2    7\n",
       "3    4\n",
       "dtype: int32"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = np.random.RandomState(42)\n",
    "ser = pd.Series(rng.randint(0, 10, 4))\n",
    "ser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A  B  C  D\n",
       "0  6  9  2  6\n",
       "1  7  4  3  7\n",
       "2  7  2  5  4"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(rng.randint(0,10,(3,4)),columns=['A','B','C','D'])\n",
    "df                                                   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1.000000</td>\n",
       "      <td>7.071068e-01</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-1.000000e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.707107</td>\n",
       "      <td>1.224647e-16</td>\n",
       "      <td>0.707107</td>\n",
       "      <td>-7.071068e-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.707107</td>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>-0.707107</td>\n",
       "      <td>1.224647e-16</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A             B         C             D\n",
       "0 -1.000000  7.071068e-01  1.000000 -1.000000e+00\n",
       "1 -0.707107  1.224647e-16  0.707107 -7.071068e-01\n",
       "2 -0.707107  1.000000e+00 -0.707107  1.224647e-16"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(df * np.pi / 4) #索引被保留"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 通用函数：索引对齐\n",
    "当在两个Series 或DataFrame 对象上进行二元计算时，Pandas 会在计算过程中对齐两个对象的索引。**当在处理不完整的数据时**，这一点非常方便"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Series索引对齐"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    NaN\n",
       "1    5.0\n",
       "2    9.0\n",
       "3    NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = pd.Series([2, 4, 6], index=[0, 1, 2])\n",
    "B = pd.Series([1, 3, 5], index=[1, 2, 3])\n",
    "A + B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以用适当的对象方法代替运算符，设置参数自定义A 或B 缺失的数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2.0\n",
       "1    5.0\n",
       "2    9.0\n",
       "3    5.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.add(B, fill_value=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### DataFrame索引对齐"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A   B\n",
       "0  1  11\n",
       "1  5   1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = pd.DataFrame(rng.randint(0, 20, (2, 2)),columns=list('AB'))\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B</th>\n",
       "      <th>A</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   B  A  C\n",
       "0  4  0  9\n",
       "1  5  8  0\n",
       "2  9  2  6"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = pd.DataFrame(rng.randint(0, 10, (3, 3)),columns=list('BAC'))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>13.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      A     B   C\n",
       "0   1.0  15.0 NaN\n",
       "1  13.0   6.0 NaN\n",
       "2   NaN   NaN NaN"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + B"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 运算符相对应的Pandas 对象方法 \n",
    "![image.png](attachment:image.png)\n",
    "##### 通用函数：DataFrame与Series的运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1</td>\n",
       "      <td>-2</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>-7</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Q  R  S  T\n",
       "0  0  0  0  0\n",
       "1 -1 -2  2  4\n",
       "2  3 -7  1  4"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = rng.randint(10, size=(3, 4))\n",
    "df = pd.DataFrame(A, columns=list('QRST'))\n",
    "df - df.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-5</td>\n",
       "      <td>0</td>\n",
       "      <td>-6</td>\n",
       "      <td>-4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-4</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Q  R  S  T\n",
       "0 -5  0 -6 -4\n",
       "1 -4  0 -2  2\n",
       "2  5  0  2  7"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.subtract(df['R'], axis=0)# 按列计算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Q    3\n",
       "S    2\n",
       "Name: 0, dtype: int32"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[0,::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Q   R    S   T\n",
       "0  0.0 NaN  0.0 NaN\n",
       "1 -1.0 NaN  2.0 NaN\n",
       "2  3.0 NaN  1.0 NaN"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df - df.iloc[0,::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 处理缺失值\n",
    "**识别缺失值的方法**\n",
    "1. 通过一个覆盖全局的掩码表示缺失值\n",
    "掩码可能是一个与原数组维度相同的完整布尔类型数\n",
    "组，也可能是用一个比特（0 或1）表示有缺失值的局部状态\n",
    "2. 用一个标签值（sentinel value）表示缺失值\n",
    "\n",
    "**None：Python对象类型的缺失值**\n",
    "None 是一个Python 对象，所以不能作为任何NumPy / Pandas 数组类型的缺失值，只能用于'object' 数组类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, None, 3, 4], dtype=object)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals1 = np.array([1, None, 3, 4])\n",
    "vals1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NaN：数值类型的缺失值**\n",
    "它会将与它接触过的数据同化。无论和NaN 进行何种操作，最终结果都是NaN\n",
    "**谨记，NaN 是一种特殊的浮点数，不是整数、字符串以及其他数据类型**\n",
    "\n",
    "**Pandas 提供了一些方法来发现、剔除、替换数据结构中的缺失值，主要包括**\n",
    "- `isnull()` 创建一个布尔类型的掩码标签缺失值\n",
    "- `notnull()` 与isnull() 操作相反\n",
    "- `dropna()` 返回一个剔除缺失值的数据\n",
    "- `fillna()` 返回一个填充了缺失值的数据副本\n",
    "\n",
    "\n",
    "##### 发现缺失值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     True\n",
       "2    False\n",
       "3     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([1, np.nan, 'hello', None])\n",
    "data.isnull()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        1\n",
       "2    hello\n",
       "dtype: object"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[data.notnull()]#布尔类型掩码数组可以直接作为Series或DataFrame 的索引使用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 剔除缺失值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        1\n",
       "2    hello\n",
       "dtype: object"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**在DataFrame 上使用它们时需要设置一些参数**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2\n",
       "0  1.0  NaN  2\n",
       "1  2.0  3.0  5\n",
       "2  NaN  4.0  6"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame([[1, np.nan, 2],[2, 3, 5],[np.nan, 4, 6]])\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2\n",
       "1  2.0  3.0  5"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dropna()#默认情况下，dropna() 会剔除任何包含缺失值的整行数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   2\n",
       "0  2\n",
       "1  5\n",
       "2  6"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dropna(axis='columns')#设置按不同的坐标轴剔除缺失值，比如axis=1（或axis='columns'）会剔除任何包含缺失值的整列数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**默认设置是`how='any'`，也就是说只要有缺失值就剔除整行或整列（通过axis 设置坐标轴）。你还可以设置`how='all'`，这样就只会剔除全部是缺失值的行或列了：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2   3\n",
       "0  1.0  NaN  2 NaN\n",
       "1  2.0  3.0  5 NaN\n",
       "2  NaN  4.0  6 NaN"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[3] = np.nan\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>4.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2\n",
       "0  1.0  NaN  2\n",
       "1  2.0  3.0  5\n",
       "2  NaN  4.0  6"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dropna(axis='columns', how='all')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**通过`thresh`参数设置行或列中非缺失值的最小数量**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1  2   3\n",
       "1  2.0  3.0  5 NaN"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dropna(axis='rows', thresh=3)#第1 行与第3 行被剔除了，因为它们只包含两个非缺失值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 填充缺失值\n",
    "`fillna()`方法，它将返回填充了缺失值后的数组副本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    NaN\n",
       "c    2.0\n",
       "d    NaN\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    0.0\n",
       "c    2.0\n",
       "d    0.0\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.fillna(0)#用0来填充"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    1.0\n",
       "c    2.0\n",
       "d    2.0\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.fillna(method='ffill')# 从前往后填充"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.0\n",
       "b    2.0\n",
       "c    2.0\n",
       "d    3.0\n",
       "e    3.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.fillna(method='bfill')# 从后往前填充"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**DataFrame 的操作方法与Series 类似，只是在填充时需要设置坐标轴参数axis**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 合并数据集 concat与append操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A0</td>\n",
       "      <td>B0</td>\n",
       "      <td>C0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A1</td>\n",
       "      <td>B1</td>\n",
       "      <td>C1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>A2</td>\n",
       "      <td>B2</td>\n",
       "      <td>C2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    A   B   C\n",
       "0  A0  B0  C0\n",
       "1  A1  B1  C1\n",
       "2  A2  B2  C2"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_df(cols, ind):\n",
    "    \"\"\"一个简单的DataFrame\"\"\"\n",
    "    data = {c: [str(c) + str(i) for i in ind]\n",
    "    for c in cols}\n",
    "    return pd.DataFrame(data, ind)\n",
    "make_df('ABC', range(3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    A   B\n",
      "1  A1  B1\n",
      "2  A2  B2\n",
      "    A   B\n",
      "3  A3  B3\n",
      "4  A4  B4\n",
      "    A   B\n",
      "1  A1  B1\n",
      "2  A2  B2\n",
      "3  A3  B3\n",
      "4  A4  B4\n"
     ]
    }
   ],
   "source": [
    "df1 = make_df('AB', [1, 2])\n",
    "df2 = make_df('AB', [3, 4])\n",
    "print(df1); print(df2); print(pd.concat([df1, df2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    A   B\n",
      "0  A0  B0\n",
      "1  A1  B1\n",
      "    C   D\n",
      "0  C0  D0\n",
      "1  C1  D1\n",
      "    A   B   C   D\n",
      "0  A0  B0  C0  D0\n",
      "1  A1  B1  C1  D1\n"
     ]
    }
   ],
   "source": [
    "df3 = make_df('AB', [0, 1])\n",
    "df4 = make_df('CD', [0, 1])\n",
    "print(df3); print(df4); print(pd.concat([df3, df4], axis=1))#水平拼接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pd.concat`**合并时会保留索引，即使索引是重复的**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    A   B\n",
      "0  A0  B0\n",
      "1  A1  B1\n",
      "    A   B\n",
      "0  A2  B2\n",
      "1  A3  B3\n",
      "    A   B\n",
      "0  A0  B0\n",
      "1  A1  B1\n",
      "0  A2  B2\n",
      "1  A3  B3\n"
     ]
    }
   ],
   "source": [
    "x = make_df('AB', [0, 1])\n",
    "y = make_df('AB', [2, 3])\n",
    "y.index = x.index # 复制索引\n",
    "print(x); print(y); print(pd.concat([x, y]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "结果中的索引是重复的。虽然DataFrame 允许这么做，但结果并不是我们想要的。pd.concat() 提供了一些解决这个问题的方法\n",
    "1. 捕捉索引重复的错误。如果你想要检测pd.concat() 合并的结果中是否出现了重复的索引，可以设置verify_integrity 参数。将参数设置为True，合并时若有索引重复就会触发异常。\n",
    "2. 忽略索引。有时索引无关紧要，那么合并时就可以忽略它们，可以通过设置ignore_index 参数来实现。如果将参数设置为True，那么合并时将会创建一个新的整数索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    A   B\n",
      "0  A0  B0\n",
      "1  A1  B1\n",
      "    A   B\n",
      "0  A2  B2\n",
      "1  A3  B3\n",
      "    A   B\n",
      "0  A0  B0\n",
      "1  A1  B1\n",
      "2  A2  B2\n",
      "3  A3  B3\n"
     ]
    }
   ],
   "source": [
    "print(x); print(y); print(pd.concat([x, y], ignore_index=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. 增加多级索引。另一种处理索引重复的方法是通过keys 参数为数据源设置多级索引标签，这样结果数据就会带上多级索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    A   B\n",
      "0  A0  B0\n",
      "1  A1  B1\n",
      "    A   B\n",
      "0  A2  B2\n",
      "1  A3  B3\n",
      "      A   B\n",
      "x 0  A0  B0\n",
      "  1  A1  B1\n",
      "y 0  A2  B2\n",
      "  1  A3  B3\n"
     ]
    }
   ],
   "source": [
    "In[12]: print(x); print(y); print(pd.concat([x, y], keys=['x', 'y']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**类似join的合并**\n",
    "默认情况下，某个位置上缺失的数据会用NaN 表示。如果不想这样，可以用join 和join_axes 参数设置合并方式。默认的合并方式是对所有输入列进行并集合并（`join='outer'`），用`join='inner' `实现对输入列的交集合并\n",
    "\n",
    "另一种合并方式是直接确定结果使用的列名，设置join_axes 参数，里面是索引对象构成的列表（是列表的列表） `print(pd.concat([df5, df6], join_axes=[df5.columns]))`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**append()方法**\n",
    "可以使用`df1.append(df2)`，效果与`pd.concat([df1, df2])` 一样"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 合并数据集 ：合并与连接\n",
    "**Pandas 的主接口是pd.merge 函数**\n",
    "1. 一对一连接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  employee        group\n",
      "0      Bob   Accounting\n",
      "1     Jake  Engineering\n",
      "2     Lisa  Engineering\n",
      "3      Sue           HR\n",
      "  employee  hire_date\n",
      "0     Lisa       2004\n",
      "1      Bob       2008\n",
      "2     Jake       2012\n",
      "3      Sue       2014\n"
     ]
    }
   ],
   "source": [
    "df1 = pd.DataFrame({'employee': ['Bob', 'Jake', 'Lisa', 'Sue'],'group': ['Accounting', 'Engineering', 'Engineering','HR']})\n",
    "df2 = pd.DataFrame({'employee': ['Lisa', 'Bob', 'Jake', 'Sue'],'hire_date': [2004, 2008, 2012, 2014]})\n",
    "print(df1); print(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>employee</th>\n",
       "      <th>group</th>\n",
       "      <th>hire_date</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bob</td>\n",
       "      <td>Accounting</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Jake</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lisa</td>\n",
       "      <td>Engineering</td>\n",
       "      <td>2004</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Sue</td>\n",
       "      <td>HR</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  employee        group  hire_date\n",
       "0      Bob   Accounting       2008\n",
       "1     Jake  Engineering       2012\n",
       "2     Lisa  Engineering       2004\n",
       "3      Sue           HR       2014"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.merge(df1, df2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pd.merge()`方法会发现两个DataFrame 都有“employee”列，并会自动以这列作为键进行连接。两个输入的合并结果是一个新的Data.`Framepd.merge()`会默认丢弃原来的行索引，不过也可以自定义\n",
    "\n",
    "2. 多对一连接\n",
    "多对一连接是指，在需要连接的两个列中，有一列的值有重复。通过多对一连接获得的结果DataFrame 将会保留重复值\n",
    "3. 多对多连接\n",
    "左右两个输入的共同列都包含重复值，那么合并的结果就是一种多对多连接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 处理时间序列\n",
    "**Pandas 所有关于日期与时间的处理方法全部都是通过Timestamp对象实现的**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timestamp('2015-07-04 00:00:00')"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date = pd.to_datetime(\"4th of July, 2015\")\n",
    "date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Saturday'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date.strftime('%A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-04', '2015-07-05', '2015-07-06', '2015-07-07',\n",
       "               '2015-07-08', '2015-07-09', '2015-07-10', '2015-07-11',\n",
       "               '2015-07-12', '2015-07-13', '2015-07-14', '2015-07-15'],\n",
       "              dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date + pd.to_timedelta(np.arange(12), 'D')#直接进行NumPy 类型的向量化运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2014-07-04    0\n",
       "2014-08-04    1\n",
       "2015-07-04    2\n",
       "2015-08-04    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = pd.DatetimeIndex(['2014-07-04', '2014-08-04',\n",
    "'2015-07-04', '2015-08-04'])\n",
    "data = pd.Series([0, 1, 2, 3], index=index)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2015-07-04    2\n",
       "2015-08-04    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['2015']#直接通过年份切片获取该年的数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**最基础的日期/ 时间对象是`Timestamp` 和`DatetimeIndex`。这两种对象可以直接使用，最常用的方法是`pd.to_datetime() `函数，它可以解析许多日期与时间格式。对`pd.to_datetime()` 传递一个日期会返回一个`Timestamp` 类型，传递一个时间序列会返回一个`DatetimeIndex` 类型**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-04', '2015-07-06', '2015-07-07', '2015-07-08'], dtype='datetime64[ns]', freq=None)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dates = pd.to_datetime( ['4th of July, 2015','2015-Jul-6', '07-07-2015', '20150708'])\n",
    "dates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当用一个日期减去另一个日期时，返回的结果是TimedeltaIndex 类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TimedeltaIndex(['0 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq=None)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dates - dates[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-03', '2015-07-04', '2015-07-05', '2015-07-06',\n",
       "               '2015-07-07', '2015-07-08', '2015-07-09', '2015-07-10'],\n",
       "              dtype='datetime64[ns]', freq='D')"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('2015-07-03', '2015-07-10') #创建时间序列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2015-07-03 00:00:00', '2015-07-03 01:00:00',\n",
       "               '2015-07-03 02:00:00', '2015-07-03 03:00:00',\n",
       "               '2015-07-03 04:00:00', '2015-07-03 05:00:00',\n",
       "               '2015-07-03 06:00:00', '2015-07-03 07:00:00'],\n",
       "              dtype='datetime64[ns]', freq='H')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.date_range('2015-07-03', periods=8, freq='H') #周期数，频率设置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Open</th>\n",
       "      <th>Close</th>\n",
       "      <th>Volume</th>\n",
       "      <th>Adj Close</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2009-12-31</th>\n",
       "      <td>311.532288</td>\n",
       "      <td>308.832428</td>\n",
       "      <td>311.208527</td>\n",
       "      <td>308.832428</td>\n",
       "      <td>2448700.0</td>\n",
       "      <td>308.832428</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010-01-04</th>\n",
       "      <td>313.579620</td>\n",
       "      <td>310.954468</td>\n",
       "      <td>312.304413</td>\n",
       "      <td>312.204773</td>\n",
       "      <td>3927000.0</td>\n",
       "      <td>312.204773</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010-01-05</th>\n",
       "      <td>312.747742</td>\n",
       "      <td>309.609497</td>\n",
       "      <td>312.418976</td>\n",
       "      <td>310.829926</td>\n",
       "      <td>6031900.0</td>\n",
       "      <td>310.829926</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010-01-06</th>\n",
       "      <td>311.761444</td>\n",
       "      <td>302.047852</td>\n",
       "      <td>311.761444</td>\n",
       "      <td>302.994293</td>\n",
       "      <td>7987100.0</td>\n",
       "      <td>302.994293</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2010-01-07</th>\n",
       "      <td>303.861053</td>\n",
       "      <td>295.218445</td>\n",
       "      <td>303.562164</td>\n",
       "      <td>295.940735</td>\n",
       "      <td>12876600.0</td>\n",
       "      <td>295.940735</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  High         Low        Open       Close      Volume  \\\n",
       "Date                                                                     \n",
       "2009-12-31  311.532288  308.832428  311.208527  308.832428   2448700.0   \n",
       "2010-01-04  313.579620  310.954468  312.304413  312.204773   3927000.0   \n",
       "2010-01-05  312.747742  309.609497  312.418976  310.829926   6031900.0   \n",
       "2010-01-06  311.761444  302.047852  311.761444  302.994293   7987100.0   \n",
       "2010-01-07  303.861053  295.218445  303.562164  295.940735  12876600.0   \n",
       "\n",
       "             Adj Close  \n",
       "Date                    \n",
       "2009-12-31  308.832428  \n",
       "2010-01-04  312.204773  \n",
       "2010-01-05  310.829926  \n",
       "2010-01-06  302.994293  \n",
       "2010-01-07  295.940735  "
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pandas_datareader import data\n",
    "goog = data.DataReader('GOOG', start='2010', end='2019',data_source='yahoo')\n",
    "goog.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "goog = goog['Close']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set()\n",
    "goog.plot();\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEECAYAAADHzyg1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XlgVOW9+P/3WWbPnkwWkpCwbwEiiwgoLlVABLVoN63UW23V69Xa2/KrrRbqt3rVXqu1t2K1VXu17a2oVRQpLsWqiCKbKLIIErKSZJJMltlnzjm/P4ZMEpIACVkm4Xn9lTlzzpnPSeB85jzL55EMwzAQBEEQBEAe7AAEQRCE+CGSgiAIghAjkoIgCIIQI5KCIAiCECOSgiAIghAjkoIgCIIQI5KCIAiCECOSgiAIghAjkoIgCIIQI5KCIAiCECOSgiAIghAjkoIgCIIQow52AKfK7fai64Nbuy89PYH6es8ZH0O8xBEPMcRLHPEQQ7zEEQ8xxEMcsiyRmuro8XFDJinoujHoSaE1jsEWDzFAfMQRDzFAfMQRDzFAfMQRDzFA/MTRE6L5SBAEQYgRSUEQBEGIEUlBEARBiBkyfQpd0bQIbreLSCQ0IJ9XWyuj6/qAfNZAxyDLCjZbAgkJyUiS1OfnFwRhaBjSScHtdmG12nE4sgfkRqaqMpHI4CaF/ojBMAw0LUJLSyNut4u0tMw+Pb8gCEPHkG4+ikRCOBxJ4pvtaZIkCVU1kZKSTigUGOxwBCEu+IMRPP7wYIcx4IZ0UgBEQuhDkiQDQ28InSD0hzc+LuPt7eWDHcaAG/JJQRAEQeg7Iin0of379/LAA7/ss/NVVVVy//3/r8/OJwhCz+mGgW4YaIM8yGSgDOmO5ngzceJk7rxzcp+dr7r6KJWVFX12PkEQeu7VzSU4U2y4Gv1ced7owQ6n34mk0Id27tzO008/CcDkyVPYvfsTGhvd3HHHSubOnc999/0Ci8XCvn178Xq9XH/9DSxefBlPPfUEADfccBMAV1+9jP/5nyd49NGHqKqq5Ne/fpAf/egng3ZdgnCmczX6BzuEATNskkJZTQtlNf1TfGpkVgIjsxJ7dEw4HOGJJ55h8+b3+MMfHmfu3PkAVFZW8MQTz9DQUM8NN1zH7Nlzuj3HD37wY55++kmREAQhTmi6jiIP71b34X11g2jOnLkAjB49hpaW5tj2JUuWoaoqmZlZTJ06nU8//WSwQhQEoYcikeE/Om/YPCmMzErs8bf5/mQ2m4HokFnDaPuHpChtv3LD0FEUtdM+kUhk4AIVBOGUhTUdC8pgh9GvxJPCANu06S0Mw6C6+ih79+5h+vRikpNTKCn5EoC9e/dQX18HRBOIpmmDGa4gCO2EB7miwUA4paTg8XhYunQpFRXRkTDPP/88S5cuZdmyZfz0pz8lFIrWHtq3bx/Lly9n0aJF3HXXXbFvvFVVVVx77bUsXryYW265Ba/X20+XE/+CwQA33HAdK1f+gJUr7yI5OYWLL15Ic3Mz3/7213jppecZN24CAIWFhXg8Lfzylz8f5KgF4cwly20TZMPa8E8KktG+3aILu3fv5u6776akpISNGzcSDoe56aab+Pvf/47D4eDOO+9k0qRJXH/99SxdupR7772X4uJifvazn1FUVMQ111zDTTfdxOWXX85ll13GY489hs/nY+XKlT0KtL7e02nBiurqUrKzC3p+1b10unWH7rvvF5x11kyWLFk2aDGczKn+Tp3ORFyuln6L41TEQwzxEkc8xBAvcfRVDK99UMLoEckcrGiMbTt7UhY56XZa/GGS7OYBiaO3ZFkiPT2h58edbIe1a9eyevVqMjOjRdLMZjOrV68mISEBSZIYP348VVVVVFZWEggEKC4uBmD58uWxJLJt2zYWLVrUYbsgCEK8avaG0HQDRe5YRiei6ew94mbTjgq8geFZF+mkHc333Xdfh9e5ubnk5uYC0NDQwF/+8hfuv/9+amtrcTqdsf2cTic1NTW43W4SEhJQVbXD9p7qKuPV1sqo6sB2i5zO561e3Tezk/vzmmVZxuk8tQ77U92vP8VDDBAfccRDDBAfcZxuDO/s/gKHw0J6uoMrxzg5UNZAWXULjkQrByqbcTgspKQ4SEm09Gscg6HXo49qamq48cYbueqqq5gzZw47duzoUJzOMIzYqJrji9b1pohdV81Huq4PaCnr4Vo6uz1d10/pkXewH43jJYZ4iSMeYoiXOPoihqbm6GS1hgYvzgQz47IT2fdlHSVlbrzeIAB19R7Cge7Xchns30W/NR915csvv+Sb3/wmX/3qV7n11lsByM7OxuVyxfapq6sjMzOTtLQ0WlpaYqNoXC5XrClKEAQhniU5ov0GsiyhKDIVrrYJssd/SR0uepwUPB4PN9xwAz/4wQ/47ne/G9uem5uLxWJhx44dAKxbt44FCxZgMpmYNWsWGzZsAOCVV15hwYIFfRS+IAhCZ8GQxo4DLpq8PVuVsdkbis0ZMqkyOemO2HvacSOPTjJGZ8jqcVJ48cUXqaur45lnnuGKK67giiuu4NFHHwXgoYce4v7772fx4sX4fD5WrFgBwOrVq1m7di1Llixh+/bt3HHHHX17FYIgCO0cKG+kvLaFzZ9WnfIxDc0BNu2s4JODdciyRGFO0gn3H65PCqfcp7Bp0yYArr/+eq6//vou95k4cSIvvvhip+25ubk899xzvYtQEAShhw5XNQFtk83CEZ3dh+qYXJiK3Wrq8hh/KNrEXVoT7QdQTtL3qYsnBWGoeeqpJ2IVWAXhTHL8jf+LikYqXB4qXN1PnG1tDkpOiI4oko8bjjrquCeHYfqgIJKCIAjDj8MabQRJS7ICbU8MJ/ryHwpH92ldl/n42cvTx2YAYDZFax8FQ8OzBM2wKYgH4Hvtfkzjz8U04TwMPYL/9f/GNPF8TOPmYUSC+P/xMKbJF2EaMwcj5MP/xqOYii7BNGoWeqCFwFu/wzxtMWrBWei+RgL/fBxz8WWo+dNO6fN37tzO44//Fk3TycnJwWazc/jwl+i6zrXXruCSSxZz6NBBfvWr+9A0DbPZzM9+tpr8/JG89NLzbNy4gUDAj8lk4he/uI+RIwu5+uplXHzxIrZt24qiKNxww/f4y1+eo6KinFtvvYOvfOWSbtdpaO+jj7bw1FO/JxKJkJOTy09+Ei2xIQjDUWsSMAwDXTfwB6Mldz4vaWBcXtf/7sOR6E2+tUM541hCaW/Z/EIA/vFRWY87sYcK8aTQx8rLy/jtb39PXt5IJkyYxNNP/5nHHnuSZ599msrKCtau/Svf/Oa3eeqp57j88q/y+eef4fV6eO+9d/nd757guefWMm/eebz00trYOdPS0nnqqecoLBzFs88+w8MP/46f//z/8ec/PxPbp3Wdht/+9nEee+zRWFE9ALfbze9//zt+/evf8cwzf+Xss8/h8cf/Z0B/L4IwkNqSAnxyqI6aBt8J9/cHI+wrdXfYlp7cOSkosowiy1hMSiyJDDfD6knBvuynsZ8lWe34WrV0fG22d3gtWxM7vrandHh9qvLzC0hISGD79o8JBgO8/vqrAAQCAUpKDjN37nwefvhXbN26hfnzFzB//nkoisIvfnEvb7/9JuXlZWzduiVWFA/gnHPmAZCVlU1mZiaqqpKdnUNLS9vEmBOt07B37x5qaqq5/fabAdB1jaSk5B5fmyAMFa0lKAygovbki2/tPdLQ4bWiyKhK99+ZVUUiog3PToVhlRTigcUS7aTSdY2f//yXTJgwEYCGhnqSkpJRVZWioml88MH7rF37Vz78cDPXX38jt912E1dd9XXOOWceaWnpHDx4IHZOk6mt00xRuq7l3tU6Da10XWPatOk8+OAjAASDQfz+M2d5QeHM4mtfk8gwOowSyki2dXlM4Lj+gePnJBzv+DVQhhPRfNRPZsyYzSuvRIfn1tXV8Z3vfIuammpWrfop+/bt5corr+LGG2/mwIH97N+/l7y8fL7xjWuZNGky7733Drres0fTrtZpaDV5chGff/4ZZWWlAPzpT3/kscd+03cXKwhxpLq+rano+Nu2pnd9s5d7WHpHkqC6wTcs5yqIJ4V+8t3vfo9f//pBrrvu6+i6zr//++3k5uZx3XX/xoMP3suf/vQHVNXEj398J4WFo3n55Rf59re/hmEYFBfP4PDhL3v0ea3rNITDodg6Da3S0zO4885VrFr1U3Rdw+nMYtWqvinOJwjxxuWOJoUkh5njv8xr3dzEe1pk0t0SrX+0t7SBolHpPQ8yjp10PYV4MRzWU+ivGPpinYZWYj2FoRlHPMQQL3EcqvZwuKyBtCQrjZ5gbIgpROcvLJyd3+mYHQdcuBr9ZCRbY/WNrjxvdLef8cr7hwHISrUztyi7w3uh/e8CkHve0jOnIJ4gCEI80g2DkqomfMHIsXb/ju9313yk6TomVSbSzfvdqXG3NVV9vK+GTw+50Mo/I3Jk55DtcxDNR8PAXXf9YrBDEIS40Nxu7oAsQzDcsW8uohkdyvkfrfdyqLIJWZJQZIkxI5KprvehnGDkUXeOupoxJIWpF90MdF4yYKgQSUEQhGEjdKxp9Zwp2dS6fUSOG0WkaTqhsI7FHB3Ft3VvdMEvh9WE1azgTLGxbH4hEqd+Q/9wTzXTfB8xo3QHu0Z+G0kZ2rfVoR29IAhCO61DSS0mpVPtolahiEZdk7/DMNSwpuM4djNX5J49JdS4fRwKW7GYM9ClroeMDyUiKQiCMGxoxyaUqUr33/R1A7btr+2wLRTWepwMMAxsoQb8lnSOOiYTMI3vcbzxSHQ0C4IwLLy3u4pPDkXLuyiyzJeVzV3u110HcE86hlMTLRTWv8/ZJU9iDbmHVckLkRQGwYED+1m+/DJuvfV7gx2KIAwbDc2BWB+CqnSecawca05qv7l9KYvjZzWfyHnTR1CVfBaHnRcQMKV0O/9hKBJJYRBs2fI+ixYt4bHH/jDYoQjCsHD8gjfKcc1HWWl2ikZHJ5m1TxbtO6JPJSkYeoTwgfeRgJApkfL0uZ3qcdc3BXoaflwRfQp9JBKJ8OtfP8Dhw1/S0NDA2LFjueuue7jnnruor68HorOcFUXh5Zej5S/MZjNVVZU0NTVRWVnOLbfcTnp6Or/97cMEgwGSk1NYufJnjBiRy/79+/jVr+4FJObMmctbb23kxRdfG8QrFoT4YBhGrCpqK0WWO9Qnmjslm9rGaL2v4xNIksNMszdESoL5pJ8VOfQRgXefwpboBLre//1Pq0448S3eDauk8Judv++0bUbmNBbkzSOkhViz++lO78/JmcXcnFl4Ql7+uKfzkqHn5Z7DzKziTtuPt2fPp6iqiSeeeAZd17n99pt5//1/kZ09gv/+70c5ePAAb765kVtv/QFXXLEcgH/7t+9x332/IDk5mV/96hHC4TA33riCBx98hOzsbLZu/ZAHH7yPRx9dw733ruK22/6T+fPn8+STna9TEM5Ub3xc3uXSmHnOBMpr22YUtzaLHChr7LCfqsicX5xLgq3rZTo77DtuPrZEJ2rOBPjy8GnFHa+GVVIYTMXFM0hKSuall9ZSVnaEiopyjh6t4v33/0VdXS1z557L9dff0OWxkycXAVBeXkpVVQV33vmfsfe8Xi9ut5v6+nrmzJkLwOWXf5UNG8RTgiAABEKR2M9l2mfUe0o5/GkykqHSoEVQMOPyJSNLDgKGh88bjqBiQpXMKJgYn55DkkPtdvSREQ4Q+OAvWM6+CtmeEk0IwPj8FL4ob+zymBZfCGffX+qAGFZJ4Y4ZN3f7nlkxn/D9BLPjhO+fzObN7/LHPz7B1772TZYsuZzGxkays3P4619f5KOPPuSDD97jb3/7M3/+8wudjm0tt61pOiNG5PKnP/312GsNt7sh9n4rZYhPjhGEvtDkCVLj7lgCfoazmF3hOuoDDXhDfry6nwhhmkLnkCY7cBtV7NE2dThmyxfwk6TbGZmUx9ajO3i95E0sigWrasWqWrBGNBaX7Saz8CxKUzMoaS7FqliRTSr1ejMKZpKkDGRJQTc0JCT+uaOC0QVDs1CeuLv0ke3bP+aiiy7msssup7Kygl27djBlylSeeuoJbrvtPznnnHlcddVSvN7uFw4vKCikubmZ3bt3MX36Wbz++qu8+eY/+N3vnqSgoJDNm9/lggsu5K23Ng7glQlCfHpnV2Xs54DhwYSVuZMK+WrWHbhcLTR6gvxrVyWJdhNjkvNwtwTJkAqYo15FxAgRIYxGiDH5DtJsqQAkW5IYkzKKQCRIIOLHE/JSpwWwX/lzTEnZ7C95m/Ulb3aK5QL1emQUvtS3c0TfRaFcjMc/ecB+F31JJIU+smzZV7nnnrt4++03UFUTU6dOo6bmKGVlpaxY8Q0UReHWW28nMTGx23OYzWZ++csHePTRhwiFQtjtDu6++x4A7r77Hh544Jc8/fSTjBxZOEBXJQjxqX3FZM2IsCvyDxLNDq6SO08gk491Omu6gUmyYMJJ+yoW83LySTi2kNXEtHFMTBuH7m/Gv+EhzMVLMY05O7bvwoILOT9vHv5IEG/Yz6ZdR4gQQj3W6Zwm5SLLMslSNjazwlBcykokhT4yZsxYnn32+VPa94Ybbor9fHwxu6KiafzhD892OiYvL5/f/e5JVFWmvLyC2267qdM+gnCm8AXb+hEO6VvxUM+8pPO73Lf1/t/dXIKuJq1JqgXJloRkcXTYrsgKdtmO3WQn1ZJCitxx+Gm6nEc6edF9e1FULx4MzagFQTij7fzCBUCdXkaZ/hn5chGjE8Z12Of4e31qYse+uVbtRx3pXjeGFkEyWbBd+iPUvCndxtA6PSE73Q5ASjfnH2pOKSl4PB6WLl1KRUUFAFu2bGHZsmUsXLiQRx55JLbfvn37WL58OYsWLeKuu+4iEolm86qqKq699loWL17MLbfccsJ2deHkcnJGiDkKwhlNNwyCho8vpHdJVtIZJ59z0iU1LaaOxepmTshk1oTMWIlrIxzAt+5eAu//L8BJS19LksRlcws4e1IWl55TwILpI5gwMvU0rio+nDQp7N69m29961scOXIEgEAgwM9+9jPWrFnDhg0b2LNnD+++G11paOXKlaxatYo33ngDwzBYu3YtAPfccw/XXHMNGzdupKioiDVr1vTfFQmCMOw5rCasVsi0p3N5/nIUSe12AZ3u5GcmkJfZtjKZZLJiLl6KuejiUz6HSVWQJSlalVWSyEi29iiGeHTSpLB27VpWr15NZmYmAJ9++ikFBQXk5+ejqirLli1j48aNVFZWEggEKC6OTvRavnw5GzduJBwOs23bNhYtWtRhe18ZqqsbxSPD0KEHdeQFYbAYhkGCksKPZt5KbkIOAKFwx6RgMUVvb+2bjaaOiQ4TXTh7ZGybVl+G1lAOgHnyhSgZvV/iV+mmXPdQctKO5vvuu6/D69raWpzOtmkZmZmZ1NTUdNrudDqpqanB7XaTkJCAqqodtvdUV2uNtrTY8ftbSExMHrBVjnq6wPdQiMEwDDQtQnOzm6SkBJzO7kdItXeq+/WneIgB4iOOeIgB+j+OXWWH2FS3gXOdC8nMTCI1LQFvSKd4gpNEu7lDDFcn20lKsMRu1k5nIudMz4udyzB0Kl95CmSVrO8+eNr3Edms4nC0JaF4+Zv0RI9HH+m63uEX17q0XXfb2y9916o3v/j6ek+HYWgAdnsqbreL5mZ3j8/XG7Iso/fwEXWoxCDLCjZbAjZb8iktNh4PC7THQwzxEkc8xNDbOCKajixJ3S6K0543GOS3Hz5NmCBHXU2xz5qYl0TAGyTgDXaKoSEYPuE5TRfcDLJKXZ2nR3F3pckbwusNxl4P5t9ElqUuv0yfTI+TQnZ2Ni6XK/ba5XKRmZnZaXtdXR2ZmZmkpaXR0tKCpmkoihLbvy8oikpGRk6fnOtUxMN/vHiIQRD60votRwBiReTCEY3Sag9jcpM6fYF86eBreHEzQ7kME71vv49U7UOvO4J52qXIKX13DxkGrUc9H5I6ffp0SkpKKC0tRdM01q9fz4IFC8jNzcVisbBjxw4A1q1bx4IFCzCZTMyaNYsNGzYA8Morr7BgwYK+vQpBEIakusbO07t2fOFiT0k9jZ5Qh+2fuj5na+3HFMjTSZfzT+tzIwe3ED6wGSMSOvnOPWA+NsLJbBq6y3L2+EnBYrHwwAMPcNtttxEMBjn//PNZvHgxAA899BB33303Ho+HKVOmsGLFCgBWr17NnXfeyeOPP05OTg4PP/xw316FIAhD0ubPjsZ+bm1qrq73ddpPN3Re/vJ1kuUMxspnd3r/VBmGjiTJWM67HkJ+JPXk5bJ7wmJSmDHeicN68oqr8Uoyhsjwna76FAZaPDTdxEMM8RJHPMQQL3HEQwy9ieOV9zuWn54zOYute6MDUc6bNoL0dkM83YFGdh2qwdNkxmE1UZCdyNjc5FOOIfzlx4T2vIn90h8hmW2nHGNvDfbfpLd9CoM/lEYQhDPW8RPK9rdb60A79n21tLkc3dCxSgk0u03ousFXZuZ1mRBORFJMff5kMByJ2keCIAya9sthAjR729r4NU2nrKWCX+9Yw5JRF1OcNLdXn6F73ciOVNTCs1AKigds+PpQJZ4UBEEYFIFQpFORuvbDUgORIM98/lcSzQmcl9uWEJwpp970Ez64Be/ffoJWVwr0bjj8mUYkBUEQBsXGrWUAjMhoq0SqtXtyeOGLV3H56rk053L8Xin2VNE6K/lUKHlFmKZchJya20dRD3+i+UgQhAFX09A2wmjMiGTMqsKR6ua29/XDlGp7WVhwIXWVDjZXto1SUrtZNrOVYRiEj+xELShGtiVhPeebfX8Bw5h4UhAEYcB9+Hl17OcEu4nicRmx17IkYcZGpjQKu7vz6mWqcuImIH/JbgJv/pbIl1v7LuAziHhSEARhUJmOq+WVYDeRqowitTkHr1/rtL9ykqRgGzUd68LbUAvO6tM4zxTiSUEQhAHXfihq6zoIBdmJlGi7OBD5kFmTnN0ditJF85GhhQl88By6px5JkjAVzkSSxO2tN8RvTRCEARUMawTDGpMKUrlsbluZ6trgUb7Ut+EONGI1dWzEmFyYhqLIXDQj7/jTAWC01BE+uAWtcm+/xn4mEM1HgiAMqCZPtIpoWpIVkxp9YghEArxTvx4LdsZxbqeho+Pykhmfn9LpXEYkhKSakVNycHzjQWRbUv9fwDAnkoIgCAMqHIkOLW3fhLT2i3V4tCZmKpczfVS0aumis0fiDYSxmtUu5xfongZ86x/EMvMKTOPmiYTQR0RSEARhQLVWW2u9z9f66thRu5tLRl5InjaeUTnRhWlsFhWbpftblGRLRMkoQE7O6u+QzygiKQiCMKD0Y1mhdfZypj2Dn86+A6ctHUU+eclpreYQcno+kmrBdvG/92usZyLR0SwIwoBqfVLQDZ299QcAyHZknlJC0L1ufOsfJLjt7/0Z4hlNJAVBEAZUa5/CPyve4bHdT1HSVHrKx8qOVKwX3YxlxuX9Fd4ZTyQFQRAGVI3bR6N+lLfL3+Hs7BmMSi444f6GYRDc/jJabXTtBdOomUgWxwmPEXpP9CkIgjCgwkaAz7R/km5N5evjrzz5ASEf4YNbQAujZI7u/wDPcCIpCIIwoD5u2UQQL/8x5XpsqrXb/YxICBQTksWB/aurkCw9X0VM6DnRfCQIQr8KRzQ2f3o0NmktSylkZuL5jEoe2e0xRjiI7/VfEdrxMgCyNVGshTBARFIQBKFfldV4qGvys/OgC4AsaRzFKbNPfJBqRkkvQE7LH4AIhfZE85EgCH3OMIzYN/vSmhZ0Q+Od5hfx7Z9JOJTbaW3mVpq7EsniQLanYD33uoEMWThGPCkIgtCn/rG1lA8/ryai6bzy/mGavSEO69up16qoqAkAkJxg6XScoYXx/+NhAu8+NdAhC+2IJwVBEPpUMKRRG/LzycE6ABr0Kkr0XYyQJpIljwEgO63zOsuSYsJ6wY3ICRmd3hMGjkgKgiD0iwqXh7ARYI/2TxxyChPk+bH32q+JED7wPpismEbPRh0xaTBCFdo5reajdevWcdlll3HZZZfx4IMPArBv3z6WL1/OokWLuOuuu4hEIgBUVVVx7bXXsnjxYm655Ra8Xu/pRy8IwoAyDAOPP9zt+xFN7/C6zigjIgWYYV6IKplw2ExMH9v2JGDoOuH97xE5uAWjtf6FMKh6nRT8fj/33Xcfzz33HOvWrWP79u1s2bKFlStXsmrVKt544w0Mw2Dt2rUA3HPPPVxzzTVs3LiRoqIi1qxZ02cXIQjCwDhY0cTb28tp8YU6vWcYBh/sruqw7ZqZF3LP3J8wZ9R4ZFniKzPyGJWThGHoGFoESZaxXfpDrBffKoacxoleJwVN09B1Hb/fTyQSIRKJoKoqgUCA4uJiAJYvX87GjRsJh8Ns27aNRYsWddguCMLQUlbTAoAvGOn03q6DdVS6PAB4jUbc+lESHWZSrSmMykni8vmjkGUJwzAIbHqSwDtPYhg6ktmOpIiW7HjR679EQkICP/jBD7j00kux2WzMnj0bk8mE09m2tqrT6aSmpga3201CQgKqqnbYLgjC0NLadBQIarFttW4fByuaUI6VwtYNjc8ibxPES0SfjVkxdziHJEkozoJj5VLF00G86XVS2L9/Py+99BLvvPMOiYmJ/PjHP+aDDz7o8AjYOla5/ZjlVj19VExPj48p7k5n4mCHEBcxQHzEEQ8xQHzEMRAxOBzRoaSN/jBFyTasZpW3dlbG3k92mGlO/oSW0jq+M3kFudnpsfcinkZ0fzNm50j4ytf7Nc54+HtA/MTRE71OCps3b2bu3Lmkp0f/6MuXL+epp57C5XLF9qmrqyMzM5O0tDRaWlrQNA1FUXC5XGRmZvbo8+rrPej64HZEOZ2JuFwtZ3wM8RJHPMQQL3H0ZQy6YVBR6yEn3YFJlfEFwny8v5b0JCteb7RURYk3SEOjnzmTsmLbAELWGjZVvsu87DmcnV3UISbfa/+N7nXj+Pp/IZ3C2gm9FQ9/j3iIQ5alXn2Z7nWfwsSJE9myZQs+nw/DMNi0aRNnn302FouFHTt2ANHRSQsWLMBkMjFr1iw2bNgAwCuvvMKCBQt6+9GCIPSj7ftr2flba97uAAAgAElEQVSFi9c/PEJVnZcPPqumsSXIl5VNHfZr8gQJhqPNSCkJFsJGgH+51pNtz+RrE5Z1Oq9l/nXYLvxevyYE4fT1+knh3HPPZe/evSxfvhyTycTUqVP5/ve/zyWXXMLdd9+Nx+NhypQprFixAoDVq1dz55138vjjj5OTk8PDDz/cZxchCGey1z4oYWxBGpPykvvkfFV1bcPFP97Xfd+fYeg0B1rwGc2km5NRsTAz4xzOHVkU60eIVO5Fry/DPG0xSlpun8Qn9C/JGCKDg0XzUfzEEC9xxEMMgxVHOKKxr9TNlFFpvPbBERwOC5fMOPFN1xeIoOk6ifa2jl9N1/BF/AAkmhNwtwR5fue7hI0AYYJECBE2gqTI2eTKE5k8KoU/HlpDUA8QoW1Y6uy0eaS0TGPh3FHY1bb+Qv+/nkKvK8F+5SoktWOHc385k/9dtNfb5iMxDkwQhqD3dh+lxReivjmIYRiE9OiN/aPPqznUdJhxoyz4In58ET/+sJ80WyrNR6JJozThbWp9LnxhHyE9OppoRuY0bij6Nh5/mH3ae7EbvoyKCTNmw8ay+YXIkoTzSC5aRMGEBRULJsnC/Pwp5DpyKMhJwuVqwYiEkFQz1vO+A5HggCUE4fSJpCAIQ0yLLxSbPOZu8bFL24DuDXMZP6a6wcee8GY+3FcX29+qWJmYNhYn0aSQZXOSZk3Brtqwq3bsJhvZ9ujAD103mKNexUXFhaQnJPLhZ7U0NAfITrfHSlN8p+ibbPnsaIeYRia1VT4N7lhHpGw39qU/QTJZQMxBGFLEX0sQhpiymugEMcMw2Ke9R4NRySTT3FiZiKnqxVwyayR2kw2bYsUX0HhnVyU60fevGLUMm6Xr//q6YWCXkkmxJmKSVeYVZeNq9JOdZo/tk5nSuZhd+1LYcno+is8tksEQJf5qgjDEGMdu7qX6J1QZBxgtz2SC9ezYLGOHlEKmva2+0D93lJ7yud0t0eGlrfOIVEUmJ91xwmNsFhUj5Ed3V4LzLEyFMzAVzujRNQnxQyQFQRhiNM3ApZdyUN9KljSG0fIsAI5Ud+7UPFTR1Glb69CSiKYjSW0VSz3+cKyMhUk98Wh1VZGJaDrnF+eSYFMJbH6GSMl2tFFrEMu0DG3irycIQ8i2/bWUHG0mSXIyI30WU5QLKR4XLS1jUjr/dy6r7ZwoDAx0w2DTjgq27m0bctq+yJ18kooDOekOMHQcJg2TqmCZtRzb4h+iOPpmWKwweMSTgiAMISW1LlQsWCQ735geLRURjmgcOtrC4armDvtGNJ1mb/RGP6kglYhmcLCiEcOIPhX4ghF8wQiHKpsYm5tMIBSdiLbo7JEnjaN4TBrjDzyNtiUFLroJOSENOSGtj69WGAwiKQjCEOEPB9kZeR2blMR0dWFse2vzTyDUsXJpdYMPgNEjkpkwMpWSo9Gk8fb28g777Tlcz9jcZHYfio5YsppPPuNYURUsBdOQrAld1jYThi7RfCQIQ4Bu6Pxu+7O0UM8IeQIZyW0jgGS58w1ZNwy2768FICc9OnLoRP0E/nalsLu7wRvhIIH3/oRWexgA8/RLMU04TySEYUYkBUEYAl47/AZH/AcZL89lZk4RZ086cUHJ/aXu2M/qsb6G3IzuRxG19icUZJ+gqqceIVLxGVrtlz2IXBhqRFIQhDj30dHtvFn6DrnyZEbKUzlrXAZm04mbeL4ob4z9rCrRb/JdfaOfPTGaXMpro/WOjk8chqETPvRRdDEciwPH1/4Lc9Elp3U9QnwTSUEQ4tyIhGxmZ81gojyfyYVpPW6uUbsYldTKdCy5lB8bpXR8sokc2UVg0++JlH4CEJ2hLAxrIikIQpwKRAIAjEzM47pJX0eWlG4TwqxJWd2ep6ukMGFkKovnjEQ9rj/CrEaTghGIzppWC2dgu/RHqAVn9eoahKFHJAVBiEO+sI9fbf8fXj/8JtA24ay7h4SxeSksmD6C6WPbZjIvnJ3P/Kk5HTqY8zOjfQbj85OxmlUS7abYe7nOBOxWleCu9XhfuAvd34wkSaj5U0Vn8hlEDEkVhDij6Rp/3PNn6vwNjE8dC7RLCt2saSzLEmlJ1thcAwC71YTdauqw38wJTmZOaFtH3aQqZKfbqa734UyxAqAWTIewH8lsRzjziKQgCHGgqs5LaqIFq1nh+S9e4YD7ENdN+jrjUkcf2yOWFU4oKy06VDXPeep19LWIzsj6D0kwVMj+BkpaPsrZ+b24CmE4EElBEAaZYRh8vK8Gkypjyyvng6qtLCy4kHNyZsX20Y4tMHWyVhxFlrn83FEnyx0dmM0q9lA9crMeHWUkiVblM5lICoIwyFrXEwxHdJINOyNNE7gw56IO+3y8LzoRLdiueag7J6tb1CpSugs5NZeiUWns0a9m9LhMkRAE0dEsCPFAN6I3+7rSVCZwIZt2VHZ4v6E5OhIpoul98nlG0Iv/nScJfbIem0Vl9uQRmE3iO6IgkoIgDLrmQAtbIs9TrR+KbUtJ7Ho+gKad3jrluqcBAMniwL70J1jmX3da5xOGH5EUBGEQhbQwT+75X4L4sEttZaeTHWZ0w6C6wRcrZHe6tOqDeP/2/xEu2Q6AklGIpJhOcpRwphHPi4IwSHRD57l9z1PWUsE0ZSFJUttQ0dLqFiwmpUO5CoDs9J4PE22tYipnjsI8dSFK9vjTjl0YvsSTgiAMkg0lb7Gz9lOWjV5Mpjyq0/vHJ4Sl8wpPujTm8SIVe/CvfwAjEkSSVSxzvo5sSzqtuIXhTSQFQRgEhhFdaXlezmwuyltw0v1HZiWesIZR9ySMkB/D33kFNkHoimg+EoQBphs6siSzbPQiDMMgcgqdx5aTVEVtT2uoQHdXYhozBzVvCkruL8RQU+GUnda/lE2bNrF8+XIuvfRS7r33XgC2bNnCsmXLWLhwIY888khs33379rF8+XIWLVrEXXfdRSQS6e60gjBs1fkbuP/j33CkuQzoWM56RIaDK88b3eVxreWvT0Vo+8sEP34BQwsf+wyREIRT1+t/LeXl5axevZo1a9bw6quvsnfvXt59911+9rOfsWbNGjZs2MCePXt49913AVi5ciWrVq3ijTfewDAM1q5d22cXIQgQHcO/r9RNfVNgsEPpkj/i5/FPn6Ex2IRNtbV7J/qkkJZk7fbYkzUdad6mWGVTy3nfwX7lKjGySOiVXieFt956iyVLlpCdnY3JZOKRRx7BZrNRUFBAfn4+qqqybNkyNm7cSGVlJYFAgOLiYgCWL1/Oxo0b++wiBCGi6azfcoQDZW7e/7SKT46tNxwvNF3jqT1/odbn4sai68iyt400Mk5Q1qg1UXS15KZx7EAjEqLi6f+PwAfPRfe1JYnOZKHXet2nUFpaislk4uabb+bo0aNccMEFjBs3Dqez7R97ZmYmNTU11NbWdtjudDqpqak5vcgFoZ3jx/IfOdrMtNHpXd5MjxcKayiKhCK3fUeKaDqabvSoLf9EXjr0GvsavuCaiVcxIW1sh/diPQpdhJrkMNPQHEDTdHRfE7I9Opch+PELRCo+x7H8F0iqmbTzv4XXcuIlOgXhVPQ6KWiaxvbt23nuueew2+3ccsstWK3WDm2kreOjdV3vcntPpKefetXH/uR0nmAN2zMoBoiPOJzORCKazpGdlTgcFiYWprH/SHTWriPJRoLtxE0oVXUe3v2sGoBrFk0EQNcN3vq4jPomf2zbqcTRnYiu4dU9LJ1wMVdOv7jT+4FQBIfDQlqqA6czkaQkK0YowJSkZpJHjcLVHGTE0U343vgHhSufQ1JMtOSPJmiWSM9wRPsMnBcw+H+NqHj5dxEP4iWOnuh1UsjIyGDu3LmkpaUBcPHFF7Nx40YUpe2blcvlIjMzk+zsbFwuV2x7XV0dmZk9+1ZTX+9B109viv/pcjoTcbkGd2hfPMQQL3G0xvDK+4dj2/JSrez4PAhAeaWbjGRbd4fjD0bYvr8Wrze6/76DtbiaArga/bFaQ/sPuUhP7r6tv30cXWn9AvSdCdcAdLlfMKQRbqzDv+sTauULCAbCpNfswLHrdcxZDzB/ciaW5ulo9iRctU1IqgVyZkLOTOrqvCeNYSDFQxzxEEM8xCHLUq++TPe6T+HCCy9k8+bNNDc3o2ka77//PosXL6akpITS0lI0TWP9+vUsWLCA3NxcLBYLO3bsAGDdunUsWHDysdmCcDLltZ7Yz8kOc4cn0MAJKopqus4bH5dR39zWKb35s6McKHPHEgLAtv21vY6tylPNo7uewB1oRJZk5HajgHSvm8CH/4fWUI6BgT1UT+KeF9BqvyQj2UZdwniUS36InJCK3WpCyRyDecrF0YQgCP2o108K06dP58Ybb+Saa64hHA4zf/58vvWtbzF69Ghuu+02gsEg559/PosXLwbgoYce4u6778bj8TBlyhRWrFjRZxchnJlafCF2HGi7aU8ZFX1qvWxuAa9/WEog2H1S2HHA1e177QVCEUqrWyjIPvVmAI8/zNYvyviXdy0RPTr0urUqqWn8uZhGzwYgvHcTSuZodHsOzbY8Gr+ymoS8Qs7SDZpHJGE/wWgkQegvpzV57eqrr+bqq6/usG3u3Lm8+uqrnfadOHEiL7744ul8nCB08NbW0g6vTccWnVcVGVmW2FNST2aajSS7ObZPRNOj7/egT2vXQdcpJQVDi2CEfOw82MQ/61/Ba7j5RmQMqdYUDEPH8DdDJASA7Egl4d8eR5JV/N4QuqwiJzmjayIr0gmHpwpCfxKzWoQhyTCMTs1DrZ3K0cEN0f6nTTsqYu/7AmHWbznCx/tqOFofbYvPTLVx8ayOS0+OzU3msrkFzJxw4n4vQ9fR6toSk++lnxPY/L981PIWTdRwkScTKZyDbhh8+mUDO8d8D9P4+bH9JTn6nax1jYTelbEQhL4lylwIQ06LP8Bb2ypITLBRp5dTrn+GQ0olx+Umx5FFtqPjzbzZFyLJbqbJG/2WXnWsc1aRJeYV5QDR5FDr9jOvKJvM1Ggl0vzMBHYcqEWRJfYcrscbiDBnclbsvIFNv0dvPAqTfgOA+axl+FQT7rJNjJFnY6TNpIboimqtQ2a7GnkXOZbAlB7MWhaE/iKSgjCkaLrG4588i1/TmWssxWwxCPg81BsVPLtvNwASEt/KvQlXLTTqR/nLti9YOmMaXm/HTtoxuW3rF7Qmh+M5U2zousGhyiYAjlbVkJ2djiSrmCZfFG0SOsY0bh6KP8y5tWmEgm3naH0qAfAGIp2GyWriSUGIIyIpCEOGbuj8ae//Ueo/xET5XLLS7MzNmkfSjpFMLkwlKS3MUW8N1d4a5hQUsL62lCr9CyqNfezZtgkJCRtJJEjpTFMuwawqtIQ82FQrqtz1fwVFlvAGop3FlnAzln/8N6FZl2OZfinqiLY5DCVNZbxT9gHJ7hkokon2DwP7S9tKYHv9YVp8IbLS7MiShGEYhCMiKQjxQyQFYUjQDZ0/73uBnbWfMk4+h+LUWVx8dgEuV0uHInLRpqOpsRIQE5VzGclUJk0wsavsMJWeGjTCSJKE3ary7L6/sb/hIE5bBiMcWeQ4sihIyqcoYxIQvVGHvC2gWAmqiVSkzKLGlcqkWg95mdEx4C5PPY/tegazYqKYaSiYKMhOJDvNzta9NQRCbcUfP/y8OvazLEf7PrLSos1VfTV7WhBOh0gKwpDw8qHX2Vq9g9HyLAqV4g7zC7rS2m4vSwoJpJFnzqY8kMiYZDMXzsjDGwhjt6gsYC4jE3I56q2h0nOUT1x7GJsyKpYU3in7IwkBF8GEWWQm5PGZ8yxsJLH9QC0G4PZ62NDwPGE9TLF8GWYpOlnOYlLISXeQaDfT4gt1GWNrZ3hNgw9FkXtUCVUQ+otICsKQcFbmNKpdIUZEokUVT2VZylkTMtl+bB7Dh3ui39Bb1y5wWKPt+lMzJjM1Y3LsmJAWxhv2YERCoJgwJ6RQJnloZjcHPdE+ixxpHEXqV9i+v4aPIi/ik9wUK5eSIKXFzpNxbBb0zAlO/rWr8qSxGnrPS78IQn8QSUGIayVNpYxKLmB0cgG5mgYSFGQnMn1sxkmPHZHhYFRzUodieVbLiZtoTJKM5c3HCablYz33Oq6ffiPv7KxAM8LMKrZz1FtDfR2EGyFMAB+NnO9chOpuG9a6bH5hrLheSoKFguxESqvbyh1cNreQFl+I93ZXxbbpxuCWcBGEViIpCHHrzSPvsO7wPzhLWUKeNdpvMCY3mamj00/peFmWGJeX3CEpjMrpuqS0oUeQZBVJVlBGTEJOig5rNR3r/FUkEwVJ+RQk5aNl6bz2wRHMko2L1BtxSgnUER1hdO7UnA7VVgGmjUknK9VOdpod3TBQFZm0JCtXnjea6gYfH7XrZxCEwSaSghCX3infzLrD/yBbGku6lBfrrE1N6FntH6tFpSArkdKa6Df1PGfnAmFa9UH8/3wc25IfoaTmYpn11dh7JjV6g7ea2/6rKLKMoshomo7VouIPtnUkdzUTWZFlRmQ4AJCPq4+dnWbnwrNyUVUx8kiIDyIpCHHng6qtvHjwVSanTian5dwOy0m23lxPlSxJnDXeiQHkHNcPYRg6kiQjJWchp45oW+2mHZMqM3V0emyE0PHsFpVQdEQp6UnWU1q/4XjJPUx0gtCfRFIQ4kqNz8X/7f87k9MnMM9xKaWetolfC2eP7NVNF2DGeGeH18HtL6PXl2FdeDuyLQn7kh93e2z7SW6tWiec+QIRVLOKLEmcN31Er2IThHgikoIQV7LsTr4/dQUT08ZTWeunFC+Lzh6JzXL6/1Tbl5iQLHYkWxLoGig9P3dWqp0at4+po9PZV9GEM7X7dRsEYSgRSUGIC5/X78csmxiXOoZpzikAGIYfoEcVTbuj+xoJvPMk5ulLUPOKME9ddFrnmz0pk2BYw2ZWCRqQZj/xCm+CMFSI3i1h0O1vOMiTnz3La4ffiM1EBjCOrV7cF8P3JYsDIxTACHhOvvMpUBUZh9WELEucU5RDaqLoFxCGB5EUhEH1ZeMRnvj0T2TaMvj+tO90nMB1LD/0NilEyj/Ft/ERDF1DUkzYr/w5prHnnH7QgjCMiaQgDJrS5nLW7H6KFGsy/1H8PRJMHUcWtT009C4rGJEwhqcBwxctSCdmDAvCyYk+BWFQaLrOGwe3YDfZub34+yRbOq9s1tPmI0OPENr5KnKiE9OE81ALZ6AWFCPJotCcIJwq8aQg9LuSo82d1kQuq/Hg9M7kfMfXSLWmdHlcjys/SAra0S/QXEeiLyVJJARB6CGRFIR+t/tQHeW1LdS6fVQ01fLg1sc4XFeDJMl4mmVeef9wrJJoOKLxyvuHKatpIXxsLsCJnhT0ljr8//oDRtCLJEnYLv1PrOdeNxCXJQjDkkgKwoA5Ul/LIzue4Ki3mip3Y4f3dh2sA+D1D6NrHu/8wsXB8pP3BRgBD5GSnbG1kiXV3B+hC8IZQyQFoV+1LkofNHy8UPYXIgSZoS4lUUqnsF1xuobmANUNvi7PcXxKiFTsIfTZmwAozkISrn0YNXdy5wMFQegxkRSEfnW4qpmQ4WdnZD1BvJylLCFJipacmDYmnbMnZcUql7ZWC83PbOt0HpHh6PSkED70EeH972JoYQAks5hNLAh9RYw+EvrVgTI3AMk2OxNC80mRs8lOt5OXkYAsSYzIcGBS5Q7lrc8an4FJlTlc1USyw4yhRwjv+Sdq4QzkJCfWedeAYkJSTMCJV2ATBKFnRFIQ+kyzN0Si3RT7Zh/UQjjsCprHxp1z/oOGliAmVSHZ0bHdPz3JSp4zgQpXdLaxLEkUZidS6/aR60zA8LcQ3P53jEgQy4zLkcwnX3VNEITeOe2k8OCDD+J2u3nggQfYt28fd911F16vl1mzZnHPPfegqipVVVWsXLmS+vp6Ro0axUMPPYTD0bMSyEJ8q2vys/nTowBced5oQlqYx3c/jdcLF6RcjizLZCR33cwjyxKzJmbisJli5a0T5AAL7Icw2/KBVBxX/xIp0dnl8YIg9J3T6lP48MMPefnll2OvV65cyapVq3jjjWgNm7Vr1wJwzz33cM0117Bx40aKiopYs2bN6UUtxJ1wRI/93Ozz8+Rn/8uhxhLS9EIaPV0vXH+8SQWppBxbWyC8718Et/wZvTk6v0FOyhQzkgVhAPQ6KTQ2NvLII49w8803A1BZWUkgEKC4OLqw+vLly9m4cSPhcJht27axaNGiDtuF4cPjD7PncAMAuqHxyNY/sa/hCyYr55Mjj2f0iM7rEXRFqzuCVncEAPO0xdiv+iVykng6EISB1Ovmo1WrVvHDH/6Qo0ejTQa1tbU4nW3/gZ1OJzU1NbjdbhISElBVtcP2nkpP77yM4mBwOjuXYzgTY4C2ON56Yz8oMg6HhU98/6Q2UsJU2/mMsUwHYPbUESddD8HQNcqffwxT+gic31oV3Zhz8rWY4+13cabHAPERRzzEAPETR0/0Kim88MIL5OTkMHfuXP7+978DoOt6h8f71gVN2i9s0qo3zQD19R50vad1D/qW05mIy9VyxsfQPo7aRj9ebxAAs0nh6qILee2TZLIjk/BGgsiShKfZT1cFqw3DQCv7BGXkdCRJxvyVW5ETnad8ffH2uzjTY4iXOOIhhniIQ5alXn2Z7lVS2LBhAy6XiyuuuIKmpiZ8Ph+SJOFytdW3qaurIzMzk7S0NFpaWtA0DUVRcLlcZGZm9uZjhQHS0BwgJcFy0qUvQ2GNLZ8dxTAMkrObmT9qGhaTwjenp7NlT3TOQV5m9/8otfLd+N94FOvFt2IaPRslo7AvL0MQhF7oVZ/CM888w/r161m3bh233347F110Effffz8Wi4UdO3YAsG7dOhYsWIDJZGLWrFls2LABgFdeeYUFCxb03RUIfWrfkQbe213Fh59Xx2Yjd6fRE8QwDA7qH/FSxf/xZfMhAJwptthC90n2jsNPjXAwVpJCyZ+O9ZL/QB01sx+uRBCE3ujTGc0PPfQQ999/P4sXL8bn87FixQoAVq9ezdq1a1myZAnbt2/njjvu6MuPFfqIYRgcOFZvyNXoZ+ve7vt+NN1g+wEXh/UdlOq7OS93LpPSxgPR5sG5U7JZMH0Eo3OTOhwXeOcJ/BsfwYiEkCQJ06hZSJKYWC8I8UIyjB4XKB4Uok+h/2Pw+MO8vb28w7Yrzxvdab/PjzRQ1eDn8+atHNQ/Yk72TL496WvI3dzc9eZaJHsykmpBqyvFiARRs8efdrzx8PeIlzjiIYZ4iSMeYoiHOHrbpyC+ogkx9U3RkhEXnpULQP5x/QG6YVBW08LB8kaatXoO6h8x1jHxxAnB68b7wt2EPnkdACWjoE8SgiAI/UOUuRCAaNNRWW0LqiKT5DDjsJo67VNa3cKOg1VISCQp6cxQljIna3KXCUH31CMnpCM7UrHM/SZqwVkDcRmCIJwmkRQEAPaUNFDfFMBmUZEkCVmW8Ef8vFO+mRqfi4qmaqq9tfgNL5OVC0iWikmX8zArnf8JhT59g+C2l3B8/T7kRCfmyRcNwhUJgtAbIimcwXRDp8JTRUVTDR+WHcJrNBKmBal0JmZ5PM2+EK/XvIpNtWLWkkghlwJTGnm2XJbMK2TH50cZkRGtYWXoEYiEkMx21NGzMCJBJHvXy2wKghC/RFIY5nRDpzHYRI3PRY3XRY3PhdOWxkUjo8OCH97xOGE9DEjYSKQwIYcUSzIewyAUUFigruCc8SNjK6NNKkhlwshUkhMsTB0dnXFs6Dq+dfchJ2dhu+hm5IR0LDMuH6xLFgThNIikMIR4/GG2bj7MtMLUTmUjglqIWp+LGm8tmqEzJyc69v/+j39Dlbc6tp9VsTIzK1p+QpZkzrFdRiRoxk4yF80YGStIV0oLuw66sEj2DglhfH7bt38jEkRSLUiyjGncPCRHWr9evyAI/U8khSFkf6mbGk8D28trOW/sFAD+fmg9O2s+xR1sW/M4xZTC7KwZyLLEBXnz0THIsjvJsmeSZE7oUGYkTc7HJ4U5Z0p2LCEAFGQnMjIrgXWbS2LbstPbVkELVBzA+7f/wrb4DpSssZiLLunvyxcEYQCIpNADgVCECpeHPGf/FecLRALUB9yMcGQjSRIfV+9kR80n1PkbqPXVo6MhNytMH/ELkuwWEkwOxqaMJsOaTmUFOKRUbEYSBysamTAylfm5c7r8HMMwOFTZhC8QpmhUOtlpnReuaZ88JhemYa/aTsRsRy0oxuwciZI7GSxiwRtBGE6GTFLQdZ3OS7j3jxq3jyS7uVMTzb92VFB+tImMZCv7jriRZYnpYzN6dG5N12gINJJiTcYkq+xvOMiWqo+pCzRQ72/AE/YC8F/zf06yJZHmUAsubyNG0EG+nEOKJQ01lMB7n1SydN5oFhZciGEYlNa0EJHrYp8TCGkYhsHhqmZGZDg6XUt5rYfPS6LlrnMy2m7srU1CAIGPnmeRqtM84QqcqTb8f/8HckIGakExssWG7eJ/79G1C4IQ/4ZMUnjio8cw7A7sqh2bamVEQjbzR0S/BR90f4kkydhVG3aTDbtqwySbelyN9VBlE3sO1wOQlWZn7pTs2HuBUISG5ujkro1by2LbR49IIrFdfR/DMPCGfZgVE2bFTHlLFe9VbKE+0ECdvwF3oBEdne+O+x4z88fRHGqhtKWCDGsa051FZFjTSLelYZZNlFa3MME6E4+WH/tLOSyWaPVRWSGi6TQ0B2LF5wAKshIprWmh2RfiSHULnx2u5/MjDVw+f1SHay2tacEacjPVqeOwRmct+//5e/TGShxX/TK6UySIZOixOka2JSuRrPFRwlwQhP4xZJKCpEdoCDRRGanG53dTYEqJJYVn9/6NhmBTh/2LnUV8b2q09tJju58Cg1jCsKs2RiUXUJQxCYCD7sNYFAvbvqzDhAUFE83ettXCSo42s/tQHQ5H9Bu0ZkQAA0UysX77PpSsUhqDbuoCDdT56wlqIb43dQXFziK8YWpQsBoAABoQSURBVC+f1e0l3ZbGqOSR5Mjj0INWDpUEmZkPZ2fP4OzsGR1i1w2DzZ8ejSWhVkWj0pkwJoOX3j6Aw6qyfsuRDu+bVJnicRmU1rRQ3xSIzVDWdSNa3K56P5HSXcizv0F9U4DxDVtJKt2NMXUmkiSjjpqB4RsbO5/13BUdzi/bOtYxEgRh+BkySWG05SpunJGHZBgEt/wZOXMMAEYkxLcPlVKbP5vIqLNQzWG8DeU408fEjpWRaA57qPXX4Y/48YX9zM+dQ1HGJHRD5ze7ft/hsyQkCnzF+N+PMDLbzssVa1ExE2nx49ObCRheLspaCA2j0dH4qOoj0iyppFpSGZczmnRbGiMc0aeMCaljeeC86KIxEU2P3siPTQD2BcLYj5s53NAc4L3dVZ2u/9JzCrCY/v/27j2oqTv///jzJCEJIRBu4Ra5CBpSL4C26k9FsVpbq3XUzna63611urvftbW6Onan3a51O2ynOq7raLvjWteOnfqtuiPTbfG6amtHWorWS1VEpVoF8QJyE+QeSM7vD8oRlLYKIRzcz+MvEhLOK+ecnPc5n/Ph89ESHGAkwE/PzZqmu14zKDYIubYCSXYhS1qst84xoPRzjvb/HZdv1BB98xrO8zmc0o8EtNTFjsOUMF15v0/8yPveLoIgPFj6TFEA2JFdwMxx8RhT57TeKL1ajS1IS2zK01y94UfN1WCmDzFQv/ufGNN+C4C7sYbf6uPRDRyGxtQ6LaQsy7hkl/J3Fw2bS3ltDScuXSfC6kOTu4m6itZmkovFlbhopkmuI9I/iIHGKEyaAB6OTCRyYBR7DstM0P4WySVBPYyJjyAs6HYbffsmrKbm28tsfezGZOz4GTsrCAB63e2hJNrmOTC4GngsogKp3xBuuU34l5+mbtc/mPjkGxQ4AzCZw9HJcWjdTk5frKAuIolL8fHQ0Pr+WPsAtIG+97UNBEF4sPWpotDerToneQUVXLimxeAzhBpfJ1qNhMYciu+UxWhCYwFwl3xP01cfog3uByYLrvLLNH9/CH3SFDAFopE02IMGEO7TRKnGwsiwcCKCTew9UoSz2YWPZOS1EQsINBs6HfXQZjVzvbxOeZyTV9LpyKIAbePRRob4UVxRx9eni3lqTNyPfsaoYAP1V76jUR/YOotdYy2l2z8gSE6kikj0rls0fvkBxknzCE4YhVs3EEPqHHQhYSSZLEAoDHuEpq8uAXCppA7aFSk/Y5/d/IIg9JA+M0pqdJg/eh+t8vj4+dZZ3pqcrg7t/5KPAV1MMpofhljQxqbg9+xf0fwwq5e78irNZz4HTevfav7+MA373sXtbABAI7WeiU/9f7HK32zff/9O4UH33iXTLctY6osI17Xe/2hpaaE++yOaC78FWnv+jLuwmqFN3/LUmDiGxVt4uOj/iG68oPyNhstniLO0Tn4z7OEk/J5dga7/iNbspkD0gyYqV0RtOushFRXq1+mgd4Ig/HfrM6eKWo2Es9mFs9lFUWlth0LQxuWWqW1oxux7+2AnSRKSJVx57GMfiy5hFNIPA7nJLU24G27h0rT2INLnfUpd+XlMT/8FgP5BILtalNffyeq+QXBLBUMfSaGksp7m459QeuwimoGphAQYqf/4DbT9hmIc/T8U3agh5cq/cOnGgH4cSBpaCo7jNviT54wmLsKfsgAH2oBIdFoNstEPZ9oi4qz9Wj+L0Uzswg2UldUwU0ng97Prrn9kAEH+Bo6eK0WjkUhLiUKn7TPnA4IgeFGfKQpt3T73HL6sPBcfZcGo1xIV6kdJRT15BRUcyy8lLSXqJ7ujtj/A6x1ptMSNJftoazdT2WJD+8NIoTNS+9Ow/13q8yvw+0VrN836PauQ9Calj7789YeMsITj6z+K0pv1BNdepKKgge8aEgj0NzCiXwpaawwA31+tpjz6l/SPi4PrrW1JX8QthEagsYbLN2ogfCopMa1n9pIkEZLomSGnA80GJo+I9sjfEgThwdVnikJE8N03RC1+emIj/AFIsAWQV1BBVW0T56+0/jfvvWhxudl/9Pb/HQQnT1AKiiRJ6B96FPmHpiUAnW0Q6G43JxnTfg361mw+Oi3H+v+v8ruqmiY+4xH6E0DcD1c2VaZYmg3BTB5h4rOjHWc5a3PnvMaCIAje0meKgiRJPPZINNfKaokJ9+d6eV2HmcEkSSI+ysKl69Wcu3yTmHB/NBoJQ7v7EAD1jS00NLUQYmnt9lNWdfuAPy7p7isMXUxyh8f65KkdHmvDbnd9jQ7zI/diORHBJsqrG5WJ7wuKbyErrzGTYAugucX9o5/VXxQFQRB6SZ8pCgBmXx/lCiDBZrnr9zHhZi5db72Ju+9I69l/oNnAsIGhmE0+tLTIylXB+OQoggOMVNW2nsE/9kh0h3sRXeGj0yo9j1pcbmrqm6lvbOZofimFxbfQajUMt1uRJAlduy6mM8fFI8uyMvicj0609wuC0DseqKNPZ72EqmqbOHWxgq9OFfOfb27fj2j7f4DKW40Y9bpuF4Q76bQagvwN2NoNnudyuZUrEc0dVySSJOGj04irBEEQelWfulK4FxOH9+OLb692eO7O4SLalFTWU1bVgLWH/4ErOMDYaYYRD4V3KEZPjIzhPodrEgRB8KgH6koBIMBPT3zUj4/R44gJYrjdCsDhM60DyQ3u37OTw6QOjSQ4wNhhgD0AW6gfFr/bVwY6rQat5oHbJIIg9CEP3JUCwJD4EAbFBaPTam6PN/SD2Ah/5QYwgFGv+8l/TvMEjUZifHJUjy5DEATBEx7IoqCRJDTa1naY9v+kNWZo5F3zCoxLjvRqNkEQBDXrVlvF2rVrmTZtGtOmTWPlypUA5OTkMH36dB5//HHWrFmjvPbcuXM8/fTTPPHEE7zxxhu0tLR0L/l9sJgNaCSJwHZNNTPHxTNzXLwY6kEQBKGdLheFnJwcsrOz+fTTT8nMzOTMmTPs2rWLJUuWsG7dOvbs2UNeXh5ZWVkAvPrqq7z55pvs27cPWZbJyMjw2If4OeOSInl8ZHSHsZMEQRCEu3W5KFitVl5//XX0ej0+Pj4kJCRQWFhIbGws0dHR6HQ6pk+fzt69e7l27RqNjY2kpKQA8PTTT7N3716PfYifo9NqMOofyJYyQRAEj+rykXLgwIHKz4WFhfznP/9h9uzZWK1W5fmwsDBu3LhBaWlph+etVis3bty4r+WFhKhjGkir1b+3I6giA6gjhxoygDpyqCEDqCOHGjKAenLcj26fPl+4cIEXX3yR1157Da1WS2FhofI7WZaRJAm3291h+Ii25+9HRUUtbrf88y/sQZ3Np/DfmEEtOdSQQS051JBBLTnUkEENOTQaqUsn09260Xz8+HFeeOEF/vCHPzBr1iwiIiIoKytTfl9WVkZYWNhdz5eXlxMWFtadRQuCIAg9oMtFobi4mPnz57Nq1SqmTZsGQHJyMgUFBVy+fBmXy8WuXbsYP348NpsNg8HA8ePHAdi+fTvjx4/3zCcQBEEQPKbLzUcbN26kqamJFStWKM/98pe/ZMWKFfz+97+nqamJtLQ0pkyZAsCqVatYunQptbW1DB48mDlz5nQ/vSAIguBRkizLvdtQf49u3qzr9XsKISFmKipq/+szqCWHGjKoJYcaMqglhxoyqCGHRiMRFPTzMzPeqc8UBUEQBKHnidHXBEEQBIUoCoIgCIJCFAVBEARBIYqCIAiCoBBFQRAEQVCIoiAIgiAoRFEQBEEQFKIoCIIgCApRFARBEASFKAqCINwXMQjCg01VRUHsbOqjhm3icrl6OwK1ta1j2KhhffS2tgmy3G53LycRekKvF4WzZ8+yfft2bt26dd8T73jSjRs3yMnJ6bXlQ+u6+Oijj7h48WKv5jh37hyffPIJ5eXlvbZNSktLefPNNwHQantvbu3c3FwWLVrE/v37AXplfeTl5fHhhx+Sn5/v9WW3l5+fz+zZs5k/fz4AGo33Dx9nzpxh06ZNXLp0yevLbu/s2bNkZGRw5cqVXs3RE7Tp6enpvbFgWZZZs2YN77//Po2NjWRlZXHr1i0GDRp010xt3rB27VqOHTtGSkoKZrO5S7PDdZXb7Wb58uVs3boVX19fdu3aRXV1NcnJyV5dF263m7fffpuPPvoIp9NJdnY2gYGB2Gw2ryy/vUuXLpGens6QIUOIi4ujpaXFqwchp9PJkiVL2LlzJ3PmzOHJJ59UfufNfWP9+vV88MEHSJLE4cOHsdlshIeHe2XZbW7evMnf/vY3tm3bhtvtJi0tjZEjR+Jyuby2TdqOF5s2bcJkMrF3714kScJut3tl+W3cbjcrVqxg8+bN+Pv78+mnn3LlyhVGjBjh1f2iJ/XabPZut5uqqirWr1+PzWbj0KFDLFq0iEmTJhEUFOS1FexyuaioqCArK4uwsDA+//xznnvuOa9u3PLycsrKyvj444+RJIn9+/eTmZnJs88+i16v91qOsrIySktLyczMBGDRokWYTCavLb+90tJS4uPjWbp0KdnZ2eh0Otxut9cOQvn5+TQ0NLBs2TIKCgpYs2YNKSkpjB49GqPR6LX9s6ioiOXLl2O326mvr/f69pBlmRUrVuDv709GRgZZWVns3r0b8O4VXEtLC1VVVSxfvhyHw8HKlSsxm29PNemt7VFVVUVJSQmbNm3C39+fvLw8fvGLXzB58uQO89b3ZV75hrW1w168eFG53CotLeXo0aP4+voCMHr0aMaPH8/SpUs7vKenc2i1WkpKSpg4cSJTpkyhoKCA3Nxcr2QoKioCoLq6mitXriht5+Xl5VgsFvR6fY+12/5YDp2u9TwhKyuLffv2sX//frZt2wZ4vg25s+3RtozvvvuOlStXEhsby7vvvgv0XHNF+xyXL18GICIiAo1GwzvvvMO+ffsICAhg8+bN/OUvf+nwnp7I0LYuiouLOXLkCNHR0Rw+fJj58+ezZs2aHtsed+YoKipCkiTS09OV7+Xp06eVK8eeutfT2bqorKykoKCAI0eOkJmZybZt28jOzubDDz8EeqZZr7PvSFVVFdnZ2fj4+ABgtVqJi4tj/fr1Hd7Tl3ml+UiSJJqbm1m4cCG+vr7Y7XYCAwM5fPgwubm5PProowCMGTOG1atXM2bMGKxWa4/nSExMRKvVUl5eTmpqKnFxcZw8eZLy8nKSkpKUA2RPZrDb7YSFhZGUlISfnx96vZ7MzEx0Oh1paWk9dvbTWY7w8HBlprxTp04xefJkbDYb6enpjB49moiICI+ekd2ZweFwKOv80KFDhIWFMWfOHObNm8eJEycYPHgwwcHBHln2j+UwmUwkJiYSEBDA999/z+XLl1m3bh3Dhw9n8uTJpKenM3bsWI/PMf5j35Fjx45x4MABSkpKmD59OqGhobz11luMGjWKyMhIj58hd7ZNDAYDzc3Nynfls88+Y9asWT1WpDtbFxaLBYvFQmFhIRs3bmTZsmUMGTKEt99+m4EDBxIbG9vj68Jut2O1WsnNzWXPnj0EBwezefNmnnrqKbZu3cro0aO93rTXE7x2TyEnJ4dNmzZhNpuxWq1ERUWRmJjIunXrGDt2LMHBwej1eq5evYrT6WTo0KE9niM8PJzIyEjCwsIwmUyYzWZqamrIz89Hr9cTGxvb4xkiIiKIiIjAarUqTUXvvfcezz//PDabDafT2WOX6Z3laONwOHA4HCQkJFBVVUVBQQFjxozxeJG6c3tERETgcrk4cOAADoeDgwcPcu7cOZqamli4cGGPtWN3tn8OHTqUuLg4oqKicDqdGI1Grl27htPpJCkpqUcztO2bFouFrVu3MmHCBGbOnElCQgLV1dWcPXuW8ePH98hJQ2fbpG0frKuro7i4GLvdTkBAgMeX3VmGsLAwIiMjiY+Pp7CwkJEjRzJjxgyioqJobGzkyy+/ZOrUqV5ZF5GRkaSlpVFRUcGhQ4eIj4/n+eefp6ioCLfb3WPHLW/qseajI0eOUFxcrDy+fv06ixcvxmw2k5ubS1VVFQkJCTz++OO88cYbyuvKy8sZPHiwV3KcPHmS6upqoLXNEiA1NZXg4GCysrKoqKjo8QwnTpxQMkBrbxeLxcLIkSP517/+xezZsz3W0+Jec9TV1SlNaAA1NTWkpqZ6JcPNmzfRarVUV1ezYMECysrK2LlzJ4WFhXz77bceK5A/t3/evHlTOVM+cOCAUrArKytJTk7u8QwnT56ktraWUaNG8fDDD/PZZ58pr6uqqmLMmDEeyfBzOe7cP/38/CgrK/PYsu8lw6lTp7h58ybQuv737t2rvK6hoYEnnnjCKzlOnjxJZWUlZrOZuXPnsmjRIubOnQtARUUFw4cP91iO3uTxK4VLly4xe/Zs8vPzOXjwIM3NzQwcOJDa2lqmTp2KLMvk5OQQHBxMTEwMY8eOZe/evRw9epR//OMf+Pn5MWPGDHx9fbtV+e83h0ajQZZljEYjTqcTWZYZMmQIBoPBaxkA9u3bx1dffcUXX3zB9evXWbJkCQMGDOhyhq7k0Ov1zJ8/n9zcXDZs2IBer2fmzJndusl5rxlCQ0OJjo7GYDAwd+5cpk6diq+vLzExMcTFxWGxWLyyX4SEhBATE4MkSSxevJi8vDzee+89/P39mT59Okajscs57iXD119/TXBwMLGxsaSmprJlyxbOnj3Lhg0bcLvdPPvssx1utPbkumi/f4aEhJCRkUFhYSETJkzo1vK7kiElJYV169Zx4cIF/vnPf9LQ0MCvfvUrr62L0NBQZV0sWbKEw4cP8/e//53Q0FCeeuopDAZDn++B5LGi0NbM8fnnnzNgwADS09Mxm8188803XLx4UWmD7N+/P8eOHaOiooKoqCgsFguPPvooiYmJJCUl8eKLL2Iymbq8YruSIzY2FrPZrPRuiY2NJSUlpcsFoSsZ+vXrR0BAACdOnODQoUP88Y9/ZN68eYSEhHQpQ1dz2Gw2AgICGD16NNHR0SQlJfHSSy91uSDcb4a2XkeDBw/GYrHgcrmQJAmHw0FgYKBX9wubzUZQUBDjxo0jOjqaYcOGMW/evC6fsNxvhrKyMvr160doaChTpkzBbrczdOhQXn755W4dBLvzHQFISUkhICCA/v37ey1DeXk5/fr1IygoiClTpij75oIFC7y+Ltq+IykpKURHR5OcnMxLL73UrRMFNel2UWhpaWHNmjXs3LkTvV7Pnj17kGWZ8ePHExUVhclkYseOHQwePFg5wAUGBpKVlYWPjw+JiYkYDAaCgoKIjo7ulRxarZbExMRut1V3J4NOpyMxMRG73c68efOUsxFv52jbJhaLhaioKOLi4rya4csvv0Sj0ZCYmIgkSWg0mm590Ty1Lmw2m9fXRfsMJpOJkJCQXv+OSJJEUFBQlwuCJ9aF2WwmMjKyy9vDUzkCAgKIjIzsVnFUo24dBSsrK1m4cCH19fVMmDCBHTt24HA4KC4u5urVqxgMBhwOB8OGDWPXrl3K+4YOHUpsbCxardYjXbjUkMNTGfz8/FSRo69nUEsONWRQSw41ZFBTDrXqVp/LyspKKisrWbduHQAFBQWcOnUKh8NBZmYmCxYsIDAwkIiICAoKCmhqakKn06HVapk3b57S17e71JBDDRnUkkMNGdSSQw0Z1JJDDRnUlEOtunWl4O/vz5QpUygtLQXAZrNhtVpJSkri/PnzymWnXq/H6XRiMBiU3iOeXLFqyKGGDGrJoYYMasmhhgxqyaGGDGrKoVpyN7jdbrmqqkp5/Otf/1rOyMiQm5ub5czMTHnSpEnysmXL5EmTJsm7d+9W3uNpasihhgxqyaGGDGrJoYYMasmhhgxqyqFW3SoK7RUVFclpaWlyTU2NLMuyXFhYKGdlZcm7d++Wr1y54qnF9IkcasiglhxqyKCWHGrIoJYcasigphxq4rFxHK5cucKkSZMoKytj0aJFWCwW/vSnP/XIcBVqz6GGDGrJoYYMasmhhgxqyaGGDGrKoSYeKwr5+fls2bKF06dP88wzz/DMM8946k/3uRxqyKCWHGrIoJYcasiglhxqyKCmHGoiybJn+lb9+9//pqSkhN/97ndeHe5ZjTnUkEEtOdSQQS051JBBLTnUkEFNOdTEY0VBVskEE2rIoYYMasmhhgxqyaGGDGrJoYYMasqhJh4rCoIgCELf1+tzNAuCIAjqIYqCIAiCoBBFQRAEQVCIoiAIgiAoPD8JsSD0cVevXmXy5MnY7XYA3G43fn5+zJkzh6lTp/7ke9euXYvD4eCxxx7zRlRB8DhRFAShE0ajke3btyuPr127xgsvvIBWq/3J6R+/+eabbs+UJwi9SRQFQbgHNpuNhQsXsnHjRux2O2+99RZ1dXWUlZXhcDh45513+Pjjj8nLy2PlypVotVrS0tJYtWoVR48exeVyMWjQIJYuXdrtqSMFoSeJewqCcI8cDgfnz58nIyODmTNnkpGRwf79+7l69SoHDx7kueeeY8iQIbz22mtMnjyZDRs2oNVq+eSTT9ixYwdhYWGsWrWqtz+GIPwkcaUgCPdIkiSMRiOvvvoqX3/9Ne+//z6FhYWUlpZSX19/1+sPHjxITU0NOTk5ADQ3N3drzm1B8AZRFAThHp0+fRq73c4rr7yCy+XiySefZMKECRQXF3c6PaPb7WbJkiWkpaUBUFdXR1NTk7djC8J9Ec1HgnAPCgoKWLduHb/5zW/Izs5m/vz5Sk+kU6dO4XK5ANBqtbS0tACQmprKli1bcDqduN1u/vznP7N69epe+wyCcC/ElYIgdKKxsZEZM2YAoNFoMBgMvPLKK0yYMIHFixczf/58TCYTZrOZESNGUFRUBMDEiRNZvXo1zc3NvPzyy/z1r39l1qxZuFwuHnroIV5//fXe/FiC8LPEgHiCIAiCQjQfCYIgCApRFARBEASFKAqCIAiCQhQFQRAEQSGKgiAIgqAQRUEQBEFQiKIgCIIgKP4/p5+Rck8oUCYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "goog.plot(alpha=0.5, style='-')\n",
    "goog.resample('BA').mean().plot(style=':')\n",
    "goog.asfreq('BA').plot(style='--');\n",
    "plt.legend(['input', 'resample', 'asfreq'],loc='upper left');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在每个数据点上，resample 反映的是上一年的均值，而asfreq 反映的是上一年最后一个工作日的收盘价\n",
    "\n",
    "**时间迁移**\n",
    "`shift() `和`tshift()`。简单来说，`shift()` 就是**迁移数据**，而`tshift() `就是**迁移索引**。两种方法都是按照频率代码进行迁移\n",
    "\n",
    "**移动时间窗口**\n",
    "`rolling()` 属性来实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
